The present technique relates to an apparatus and method for controlling debugging of program instructions including a transaction.
There may be provided data processing systems supporting transactions in which a number of program instructions execute to generate updates to state data and to commit the updates if the transaction completes without a conflict. Since the updates are only committed if the transaction completes without a conflict, such updates are also referred to herein as speculative updates until such time as they are committed. Such transactions may be used, for example, to facilitate multi-threaded processing using a shared memory in which transactions using data values within the shared memory may be allowed to proceed in parallel relying upon the ability to avoid committing speculative updates should a conflict arise between memory accesses. In most cases, such conflicts do not arise and accordingly the parallel processing proceeds efficiently without the need to support the overhead of more rigid mechanisms, such as the use of memory locks, and yet when a conflict does arise it is possible to recover as the speculative updates to state data will not have been committed.
It is often desired to perform debugging of program instructions executed by processing circuitry, but this can be problematic when those program instructions include transactions of the above type. In particular, when debugging transactions, the action of inspecting the processing circuitry state during a transaction can give rise to a probe effect that influences execution of the remaining portion of the transaction. This probe effect can be quite significant, and for example certain types of debugging activity can cause the transaction to abort, which prevents forward progress in the processing of the transaction.